The use of compiler optimizations makes possible much faster execution of an executable file, but optimized code is much more difficult to debug as a result of the movement, reordering, substitution and other operations performed upon the code as a result of the optimization procedures. In particular, it is difficult to determine the present value of a user-defined variable when that variable has been replaced with a compiler synthesized variable.
In previous debuggers, a user's program variable was recorded by the compiler to be in a specific location. The debugger accesses that one specific location in memory to evaluate the variable. With sophisticated optimizations, a variable is defined to be in zero or more locations over a range of addresses.
In such preexisting debugger programs, each user variable is mapped directly to a section of memory in the program's dataspace. That is, each variable has a definite location in either the user's static section of memory or locally in the current call frame. However, as optimizing compilers have become more sophisticated, many uses of variables are replaced with more efficient uses of different variables. If the debugger program were to read the value of a variable at the allocated address for that user-defined variable, it would be erroneous. Therefore, there exists a need for an explicit method that relates compiler synthesized variables to user-defined variables.